;int generar_codigo ( nodo_arbol_t *a, nodo_arbol_t *h,codigo_t *c)
%include "macros.mac"
extern malloc
extern free

global generar_codigo

section .text

%define a [ebp+8]
%define h [ebp+12]
%define c [ebp+16]
%define codigo [ebp-4]
%define iter [ebp-8]
%define codigo_derecho [ebp-12]
%define codigo_reves [ebp-16]

%define off_cod_der 0
%define off_cod_rev 4
%define off_cod_tam 8
%define off_cod_valido 12

%define off_a_simbolo 0
%define off_a_apariciones 1
%define off_a_valido 5
%define off_a_izq 13
%define off_a_der 17
%define off_a_padre 9

generar_codigo:
	convencion_C 16

	mov eax,a			;if a==nul
	cmp eax,0
	jne a_no_es_null			;then
a_es_null:
	mov eax,c				;eax==c
	mov dword[eax+off_a_valido],0		;c->valido ==0
	mov dword eax,0
	jmp fin					;termina aca

a_no_es_null:
	
	mov dword eax,128
	
	push eax		;32*sizeof unsigned int
	call malloc		;unsigned int* codigo = (uint*)malloc(32*sizeof(uint))
	add esp,4		;eax = codigo
	mov codigo,eax		;ebx = codigo
	xor ecx,ecx		;int i=0
ciclo1:
	mov dword [eax+4*ecx],0
	inc ecx
	cmp dword ecx,32
	jne ciclo1

	mov edx,h
	mov iter,edx		;iter=h
	xor ecx,ecx		;int tam=0


ciclo2:
	
	mov esi,[edx+off_a_padre]	;esi=iter->padre
	cmp dword esi,0			;if iter->padre == null
	je termino_ciclo2		;break



	mov edi,[esi+off_a_izq]		;edi es (iter->padre)->izq
	cmp edx,edi			;IF(iter == (iter->padre)->izq
	jne es_hijo_derecho
es_hijo_izquierdo:			;THEN
	mov ebx,codigo
	mov dword [ebx+4*ecx],0		;codigo[i]=0
	jmp continuar_ciclo2
es_hijo_derecho:			;ELSE
	mov ebx,codigo
	mov dword [ebx+4*ecx],1		;codigo[i]=1

continuar_ciclo2:
	mov edx,[edx+off_a_padre]	;iter = iter->padre
	inc ecx				;tam++
	cmp dword ecx,32		;si tam == 32 salgo del ciclo, sino itero
	jne ciclo2

termino_ciclo2:

	cmp dword ecx,32	;IF tam==32
	jne tamanio_de_codigo_valido

	
tamanio_de_codigo_no_valido:	;THEN
	mov edx,c				;edx=c
	mov dword [edx+off_cod_valido],0	;c->valido = 0
	mov dword eax,0
	jmp fin
tamanio_de_codigo_valido:
	
	mov edi,ecx			;ahora edi==tam


	mov dword  codigo_derecho,0
	mov dword codigo_reves,0
	xor ecx,ecx				;int = 0

	mov ebx,codigo
	
ciclo3:			;while i<tam == whilw ecx<edi

	mov eax,codigo_reves
	shl eax,1				;codigo_reves*2
	add eax,[ebx+4*ecx]		;codigo_reves*2 +codigo[i]
	mov codigo_reves,eax
	mov edx,edi			;edx = tam
	
	sub edx,ecx			;edx = tam-i
	dec edx				;edx =tam -i -1

	mov esi,codigo_derecho
	shl esi,1
	
	add esi,[ebx+4*edx] 		;codigo_derecho*2+codigo[tam-i-1]
	mov codigo_derecho,esi


	inc ecx				;i++
	cmp ecx,edi			;si i llego a tam salgo del ciclo3, sino sigo iterando
	jne ciclo3

	mov edx, c
	mov esi,codigo_derecho
	mov [edx+off_cod_der],esi		;c->codigo =codigo_derecho
	mov eax,codigo_reves
	mov [edx+off_cod_rev],eax		;c->codigo_rev = codivo_reves
	mov [edx+off_cod_tam],edi		;c->long_codigo = tam
	mov dword [edx+off_cod_valido],1	;c->valido = 1


	mov dword eax,1				;devuelvo 1, no hubo error
fin:

	push dword codigo
	call free
	add esp,4

convencion_C_fin 16
ret

